package com.example.testplatform.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.testplatform.common.LogUtils;
import com.example.testplatform.entity.Role;
import com.example.testplatform.mapper.RoleMapper;
import com.example.testplatform.service.RoleService;
import org.slf4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 角色Service实现类
 */
@Service
public class RoleServiceImpl extends ServiceImpl<RoleMapper, Role> implements RoleService {
    
    private static final Logger logger = LogUtils.getLogger(RoleServiceImpl.class);
    
    @Autowired
    private RoleMapper roleMapper;
    
    /**
     * 获取所有角色
     * @return 角色列表
     */
    @Override
    public List<Role> getAllRoles() {
        long startTime = System.currentTimeMillis();
        LogUtils.logBusiness(logger, "ROLE_QUERY_ALL_START", "system", "开始获取所有角色列表");
        try {
            LogUtils.debug(logger, () -> "【角色管理】获取所有角色列表请求开始");
            
            LogUtils.info(logger, () -> "【角色管理】准备执行查询所有角色操作");
            List<Role> roles = roleMapper.findAll();
            LogUtils.debug(logger, () -> "【角色管理】查询所有角色完成，返回角色数量: " + (roles != null ? roles.size() : 0));
            
            // 记录返回的角色简要信息
            if (roles != null && !roles.isEmpty()) {
                StringBuilder roleNames = new StringBuilder();
                for (int i = 0; i < Math.min(5, roles.size()); i++) {
                    if (i > 0) roleNames.append(", ");
                    roleNames.append(roles.get(i).getRoleName()).append("(ID:").append(roles.get(i).getId()).append(")");
                }
                if (roles.size() > 5) {
                    roleNames.append(" 等 ").append(roles.size()).append(" 个角色");
                }
                LogUtils.debug(logger, () -> "【角色管理】返回的角色列表: " + roleNames.toString());
            }
            
            LogUtils.info(logger, () -> "【角色管理】获取所有角色列表成功，共 " + (roles != null ? roles.size() : 0) + " 个角色");
            LogUtils.logPerformance(logger, "getAllRoles", startTime, System.currentTimeMillis());
            LogUtils.logBusiness(logger, "ROLE_QUERY_ALL_SUCCESS", "system", "获取所有角色列表成功，角色数量: " + (roles != null ? roles.size() : 0));
            return roles;
        } catch (Exception e) {
            LogUtils.error(logger, "【角色管理】获取所有角色列表异常: " + LogUtils.formatException(e));
            LogUtils.logBusiness(logger, "ROLE_QUERY_ALL_FAIL", "system", "获取所有角色列表失败: " + e.getMessage());
            throw e;
        }
    }
    
    /**
     * 根据ID获取角色
     * @param id 角色ID
     * @return 角色信息
     */
    @Override
    public Role getRoleById(Long id) {
        long startTime = System.currentTimeMillis();
        LogUtils.logBusiness(logger, "ROLE_QUERY_BY_ID_START", "system", "开始根据ID查询角色: " + id);
        try {
            // 参数验证
            if (id == null || id <= 0) {
                LogUtils.warn(logger, "【角色管理】角色ID参数无效: {}", id);
                LogUtils.logBusiness(logger, "ROLE_QUERY_BY_ID_FAIL", "system", "根据ID查询角色失败: 角色ID无效");
                return null;
            }
            
            LogUtils.debug(logger, () -> "【角色管理】根据ID获取角色请求开始，角色ID: " + id);
            
            LogUtils.info(logger, () -> "【角色管理】准备执行根据ID查询角色操作，ID: " + id);
            Role role = roleMapper.findById(id);
            
            if (role == null) {
                LogUtils.warn(logger, "【角色管理】未找到ID为 {} 的角色", id);
                LogUtils.logBusiness(logger, "ROLE_QUERY_BY_ID_NOT_FOUND", "system", "未找到角色: ID=" + id);
            } else {
                LogUtils.info(logger, () -> "【角色管理】找到角色: " + role.getRoleName() + " (ID: " + role.getId() + "), 角色代码: " + role.getRoleCode() + ", 状态: " + role.getStatus());
                LogUtils.debug(logger, () -> "【角色管理】角色详情: ID=" + role.getId() + ", 名称=" + role.getRoleName() + ", 代码=" + role.getRoleCode() + ", 描述=" + (role.getDescription() != null ? role.getDescription() : "空") + ", 状态=" + role.getStatus());
            }
            
            LogUtils.debug(logger, () -> "【角色管理】根据ID " + id + " 获取角色结果: " + (role != null ? "找到角色" : "未找到角色"));
            LogUtils.logPerformance(logger, "getRoleById", startTime, System.currentTimeMillis());
            LogUtils.logBusiness(logger, "ROLE_QUERY_BY_ID_COMPLETE", "system", "根据ID查询角色完成，ID: " + id + ", 结果: " + (role != null ? "找到角色" : "未找到角色"));
            return role;
        } catch (Exception e) {
            LogUtils.error(logger, "【角色管理】根据ID获取角色异常: " + id + ", 错误: " + LogUtils.formatException(e));
            LogUtils.logBusiness(logger, "ROLE_QUERY_BY_ID_EXCEPTION", "system", "根据ID查询角色异常: " + e.getMessage());
            throw e;
        }
    }
    
    /**
     * 创建角色
     * @param role 角色信息
     * @return 创建结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean createRole(Role role) {
        long startTime = System.currentTimeMillis();
        LogUtils.logBusiness(logger, "ROLE_CREATE_START", "system", "开始创建角色");
        try {
            // 参数验证
            if (role == null) {
                LogUtils.warn(logger, "【角色管理】创建角色失败: 角色对象为空");
                LogUtils.logBusiness(logger, "ROLE_CREATE_FAIL", "system", "创建角色失败: 角色对象为空");
                return false;
            }
            
            if (role.getRoleName() == null || role.getRoleName().trim().isEmpty()) {
                LogUtils.warn(logger, "【角色管理】创建角色失败: 角色名称不能为空");
                LogUtils.logBusiness(logger, "ROLE_CREATE_FAIL", "system", "创建角色失败: 角色名称为空");
                return false;
            }
            
            if (role.getRoleCode() == null || role.getRoleCode().trim().isEmpty()) {
                LogUtils.warn(logger, "【角色管理】创建角色失败: 角色代码不能为空");
                LogUtils.logBusiness(logger, "ROLE_CREATE_FAIL", "system", "创建角色失败: 角色代码为空");
                return false;
            }
            
            LogUtils.logBusiness(logger, "ROLE_CREATE_ATTEMPT", "system", "创建角色尝试: 角色名称=" + role.getRoleName() + ", 角色代码=" + role.getRoleCode());
            LogUtils.debug(logger, () -> "【角色管理】创建角色请求开始，角色名称: " + role.getRoleName() + ", 角色代码: " + role.getRoleCode());
            LogUtils.info(logger, () -> "【角色管理】准备创建新角色: " + role.getRoleName());
            
            // 检查角色代码是否已存在
            LogUtils.info(logger, () -> "【角色管理】准备检查角色代码是否已存在: " + role.getRoleCode());
            if (checkRoleCodeExists(role.getRoleCode(), null)) {
                LogUtils.warn(logger, "【角色管理】创建角色失败: 角色代码 {} 已存在", role.getRoleCode());
                LogUtils.logBusiness(logger, "ROLE_CREATE_FAIL", "system", "创建角色失败: 角色代码已存在，代码=" + role.getRoleCode());
                return false;
            }
            
            // 记录创建前的完整角色信息
            LogUtils.debug(logger, () -> "【角色管理】待创建角色完整信息: " +
                    "名称=" + role.getRoleName() + ", " +
                    "代码=" + role.getRoleCode() + ", " +
                    "描述=" + (role.getDescription() != null ? role.getDescription() : "空") + ", " +
                    "状态=" + (role.getStatus() != null ? role.getStatus() : "空"));
            
            // 设置创建时间
            LogUtils.debug(logger, () -> "【角色管理】设置角色创建时间和更新时间");
            role.setCreateTime(LocalDateTime.now());
            role.setUpdateTime(LocalDateTime.now());
            LogUtils.debug(logger, () -> "【角色管理】角色时间设置完成，创建时间: " + role.getCreateTime());
            
            LogUtils.info(logger, () -> "【角色管理】开始执行数据库保存操作");
            boolean result = save(role);
            
            if (result) {
                LogUtils.info(logger, () -> "【角色管理】创建角色成功: 角色名称=" + role.getRoleName() + ", 角色ID=" + role.getId() + ", 角色代码=" + role.getRoleCode());
                LogUtils.debug(logger, () -> "【角色管理】新角色ID分配: " + role.getId());
                LogUtils.logBusiness(logger, "ROLE_CREATE_SUCCESS", "system", "创建角色成功: 角色名称=" + role.getRoleName() + ", 角色ID=" + role.getId() + ", 角色代码=" + role.getRoleCode());
            } else {
                LogUtils.warn(logger, "【角色管理】创建角色失败: 角色名称={}", role.getRoleName());
                LogUtils.logBusiness(logger, "ROLE_CREATE_FAIL", "system", "创建角色失败: 角色名称=" + role.getRoleName());
            }
            
            LogUtils.logPerformance(logger, "createRole", startTime, System.currentTimeMillis());
            return result;
        } catch (Exception e) {
            LogUtils.error(logger, "【角色管理】创建角色异常: 角色名称=" + role.getRoleName() + ", 角色代码=" + role.getRoleCode() + ", 错误: " + LogUtils.formatException(e));
            LogUtils.logBusiness(logger, "ROLE_CREATE_EXCEPTION", "system", "创建角色异常: " + e.getMessage());
            throw e;
        }
    }
    
    /**
     * 更新角色
     * @param role 角色信息
     * @return 更新结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean updateRole(Role role) {
        long startTime = System.currentTimeMillis();
        LogUtils.logBusiness(logger, "ROLE_UPDATE_START", "system", "开始更新角色");
        try {
            // 参数验证
            if (role == null) {
                LogUtils.warn(logger, "【角色管理】更新角色失败: 角色对象为空");
                LogUtils.logBusiness(logger, "ROLE_UPDATE_FAIL", "system", "更新角色失败: 角色对象为空");
                return false;
            }
            
            if (role.getId() == null || role.getId() <= 0) {
                LogUtils.warn(logger, "【角色管理】更新角色失败: 角色ID不能为空或无效");
                LogUtils.logBusiness(logger, "ROLE_UPDATE_FAIL", "system", "更新角色失败: 角色ID无效");
                return false;
            }
            
            LogUtils.logBusiness(logger, "ROLE_UPDATE_ATTEMPT", "system", "更新角色尝试: 角色ID=" + role.getId() + ", 角色名称=" + role.getRoleName());
            LogUtils.debug(logger, () -> "【角色管理】更新角色请求开始，角色ID: " + role.getId() + ", 角色名称: " + (role.getRoleName() != null ? role.getRoleName() : "空"));
            
            // 检查角色是否存在
            LogUtils.info(logger, () -> "【角色管理】准备检查角色是否存在，ID: " + role.getId());
            Role existingRole = roleMapper.findById(role.getId());
            if (existingRole == null) {
                LogUtils.warn(logger, "【角色管理】更新角色失败: 未找到ID为 {} 的角色", role.getId());
                LogUtils.logBusiness(logger, "ROLE_UPDATE_FAIL", "system", "更新角色失败: 角色不存在，ID=" + role.getId());
                return false;
            }
            
            LogUtils.info(logger, () -> "【角色管理】找到待更新角色: " + existingRole.getRoleName() + " (ID: " + existingRole.getId() + ")");
            
            // 检查角色代码是否已存在（排除当前角色）
            LogUtils.info(logger, () -> "【角色管理】准备检查角色代码是否已存在(排除当前角色): " + role.getRoleCode() + ", 当前角色ID=" + role.getId());
            if (checkRoleCodeExists(role.getRoleCode(), role.getId())) {
                LogUtils.warn(logger, "【角色管理】更新角色失败: 角色代码 {} 已存在", role.getRoleCode());
                LogUtils.logBusiness(logger, "ROLE_UPDATE_FAIL", "system", "更新角色失败: 角色代码已存在，代码=" + role.getRoleCode());
                return false;
            }
            
            // 记录更新前后的信息对比
            StringBuilder updateLog = new StringBuilder();
            updateLog.append("【角色管理】角色更新信息对比 - 角色ID: " + role.getId() + ", ");
            if (!equals(existingRole.getRoleName(), role.getRoleName())) {
                updateLog.append("名称从'" + existingRole.getRoleName() + "'变更为'" + role.getRoleName() + "', ");
            }
            if (!equals(existingRole.getRoleCode(), role.getRoleCode())) {
                updateLog.append("代码从'" + existingRole.getRoleCode() + "'变更为'" + role.getRoleCode() + "', ");
            }
            if (!equals(existingRole.getDescription(), role.getDescription())) {
                updateLog.append("描述已变更, ");
            }
            if (!equals(existingRole.getStatus(), role.getStatus())) {
                updateLog.append("状态从'" + existingRole.getStatus() + "'变更为'" + role.getStatus() + "', ");
            }
            
            if (updateLog.length() > 0) {
                LogUtils.debug(logger, () -> updateLog.toString());
            } else {
                LogUtils.debug(logger, () -> "【角色管理】更新角色: 未检测到任何字段变更");
            }
            
            // 设置更新时间
            LogUtils.debug(logger, () -> "【角色管理】设置角色更新时间");
            role.setUpdateTime(LocalDateTime.now());
            LogUtils.debug(logger, () -> "【角色管理】角色时间设置完成，更新时间: " + role.getUpdateTime());
            
            LogUtils.info(logger, () -> "【角色管理】开始执行数据库更新操作，ID: " + role.getId());
            boolean result = updateById(role);
            
            if (result) {
                LogUtils.info(logger, () -> "【角色管理】更新角色成功: 角色ID=" + role.getId() + ", 角色名称=" + role.getRoleName() + ", 角色代码=" + role.getRoleCode());
                LogUtils.logBusiness(logger, "ROLE_UPDATE_SUCCESS", "system", "更新角色成功: 角色ID=" + role.getId() + ", 角色名称=" + role.getRoleName() + ", 角色代码=" + role.getRoleCode());
            } else {
                LogUtils.warn(logger, "【角色管理】更新角色失败: 角色ID={}", role.getId());
                LogUtils.logBusiness(logger, "ROLE_UPDATE_FAIL", "system", "更新角色失败: 角色ID=" + role.getId());
            }
            
            LogUtils.logPerformance(logger, "updateRole", startTime, System.currentTimeMillis());
            return result;
        } catch (Exception e) {
            LogUtils.error(logger, "【角色管理】更新角色异常: 角色ID=" + role.getId() + ", 角色名称=" + (role.getRoleName() != null ? role.getRoleName() : "空") + ", 错误: " + LogUtils.formatException(e));
            LogUtils.logBusiness(logger, "ROLE_UPDATE_EXCEPTION", "system", "更新角色异常: " + e.getMessage());
            throw e;
        }
    }
    
    /**
     * 删除角色
     * @param id 角色ID
     * @return 删除结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean deleteRole(Long id) {
        long startTime = System.currentTimeMillis();
        LogUtils.logBusiness(logger, "ROLE_DELETE_START", "system", "开始删除角色");
        try {
            // 参数验证
            if (id == null || id <= 0) {
                LogUtils.warn(logger, "【角色管理】删除角色失败: 角色ID不能为空或无效");
                LogUtils.logBusiness(logger, "ROLE_DELETE_FAIL", "system", "删除角色失败: 角色ID无效");
                return false;
            }
            
            LogUtils.logBusiness(logger, "ROLE_DELETE_ATTEMPT", "system", "删除角色尝试: 角色ID=" + id);
            LogUtils.debug(logger, () -> "【角色管理】删除角色请求开始，角色ID: " + id);
            
            // 检查角色是否存在
            LogUtils.info(logger, () -> "【角色管理】准备检查角色是否存在，ID: " + id);
            Role existingRole = roleMapper.findById(id);
            if (existingRole == null) {
                LogUtils.warn(logger, "【角色管理】删除角色失败: 未找到ID为 {} 的角色", id);
                LogUtils.logBusiness(logger, "ROLE_DELETE_FAIL", "system", "删除角色失败: 角色不存在，ID=" + id);
                return false;
            }
            
            // 记录将要删除的角色信息
            LogUtils.info(logger, () -> "【角色管理】找到待删除角色: " + existingRole.getRoleName() + " (ID: " + existingRole.getId() + "), 角色代码: " + existingRole.getRoleCode() + ", 状态: " + existingRole.getStatus());
            LogUtils.debug(logger, () -> "【角色管理】待删除角色详细信息: " +
                    "ID=" + existingRole.getId() + ", " +
                    "名称=" + existingRole.getRoleName() + ", " +
                    "代码=" + existingRole.getRoleCode() + ", " +
                    "描述=" + (existingRole.getDescription() != null ? existingRole.getDescription() : "空") + ", " +
                    "状态=" + existingRole.getStatus());
            
            // 检查是否有相关的用户（假设有一个方法可以检查）
            // boolean hasRelatedUsers = checkRelatedUsers(id);
            // if (hasRelatedUsers) {
            //     LogUtils.warn(logger, "【角色管理】删除角色失败: 角色ID={} 存在相关的用户，不允许删除", id);
            //     LogUtils.logBusiness(logger, "ROLE_DELETE_FAIL", "system", "删除角色失败: 角色存在相关用户");
            //     return false;
            // }
            
            LogUtils.info(logger, () -> "【角色管理】开始执行数据库删除操作，ID: " + id);
            boolean result = removeById(id);
            
            if (result) {
                LogUtils.info(logger, () -> "【角色管理】删除角色成功: 角色ID=" + id + " - " + existingRole.getRoleName() + " (" + existingRole.getRoleCode() + ")");
                LogUtils.logBusiness(logger, "ROLE_DELETE_SUCCESS", "system", "删除角色成功: 角色ID=" + id + ", 名称=" + existingRole.getRoleName());
            } else {
                LogUtils.warn(logger, "【角色管理】删除角色失败: 角色ID={}", id);
                LogUtils.logBusiness(logger, "ROLE_DELETE_FAIL", "system", "删除角色失败: 角色ID=" + id);
            }
            
            LogUtils.logPerformance(logger, "deleteRole", startTime, System.currentTimeMillis());
            return result;
        } catch (Exception e) {
            LogUtils.error(logger, "【角色管理】删除角色异常: 角色ID=" + id + ", 错误: " + LogUtils.formatException(e));
            LogUtils.logBusiness(logger, "ROLE_DELETE_EXCEPTION", "system", "删除角色异常: " + e.getMessage());
            throw e;
        }
    }
    
    /**
     * 批量删除角色
     * @param ids 角色ID列表
     * @return 删除结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean deleteRoles(List<Long> ids) {
        long startTime = System.currentTimeMillis();
        LogUtils.logBusiness(logger, "ROLE_BATCH_DELETE_START", "system", "开始批量删除角色");
        try {
            LogUtils.logBusiness(logger, "ROLE_BATCH_DELETE_ATTEMPT", "system", "批量删除角色尝试: 角色数量=" + (ids != null ? ids.size() : 0));
            LogUtils.debug(logger, () -> "【角色管理】批量删除角色请求开始，角色数量: " + (ids != null ? ids.size() : 0));
            
            if (ids == null || ids.isEmpty()) {
                LogUtils.warn(logger, "【角色管理】批量删除角色失败: 角色ID列表为空");
                LogUtils.logBusiness(logger, "ROLE_BATCH_DELETE_FAIL", "system", "批量删除角色失败: 角色ID列表为空");
                return false;
            }
            
            // 记录要删除的角色ID列表
            LogUtils.debug(logger, () -> "【角色管理】待删除角色ID列表: " + ids.toString());
            
            // 检查是否有角色存在相关的用户（假设有一个方法可以检查）
            // boolean hasRelatedUsers = checkBatchRelatedUsers(ids);
            // if (hasRelatedUsers) {
            //     LogUtils.warn(logger, "【角色管理】批量删除角色失败: 部分角色存在相关的用户，不允许删除");
            //     LogUtils.logBusiness(logger, "ROLE_BATCH_DELETE_FAIL", "system", "批量删除角色失败: 部分角色存在相关用户");
            //     return false;
            // }
            
            // 批量删除角色
            LogUtils.info(logger, () -> "【角色管理】开始执行批量删除角色操作，请求删除角色数量: " + ids.size());
            LogUtils.debug(logger, () -> "【角色管理】执行批量删除角色操作");
            Integer count = roleMapper.deleteBatch(ids);
            boolean result = count != null && count > 0;
            
            if (result) {
                LogUtils.info(logger, () -> "【角色管理】批量删除角色成功: 实际删除角色数量=" + count + ", 请求删除角色数量=" + ids.size());
                LogUtils.logBusiness(logger, "ROLE_BATCH_DELETE_SUCCESS", "system", "批量删除角色成功: 实际删除角色数量=" + count + ", 请求删除角色数量=" + ids.size());
            } else {
                LogUtils.warn(logger, "【角色管理】批量删除角色失败: 未删除任何角色");
                LogUtils.logBusiness(logger, "ROLE_BATCH_DELETE_FAIL", "system", "批量删除角色失败: 未删除任何角色");
            }
            
            LogUtils.logPerformance(logger, "deleteRoles", startTime, System.currentTimeMillis());
            return result;
        } catch (Exception e) {
            LogUtils.error(logger, "【角色管理】批量删除角色异常: 角色数量=" + (ids != null ? ids.size() : 0) + ", 错误: " + LogUtils.formatException(e));
            LogUtils.logBusiness(logger, "ROLE_BATCH_DELETE_EXCEPTION", "system", "批量删除角色异常: " + e.getMessage());
            throw e;
        }
    }
    
    /**
     * 检查角色代码是否已存在
     * @param roleCode 角色代码
     * @param id 角色ID（更新时使用）
     * @return 是否存在
     */
    @Override
    public boolean checkRoleCodeExists(String roleCode, Long id) {
        long startTime = System.currentTimeMillis();
        LogUtils.logBusiness(logger, "ROLE_CODE_CHECK_START", "system", "开始检查角色代码是否已存在");
        try {
            // 参数验证
            if (roleCode == null || roleCode.trim().isEmpty()) {
                LogUtils.warn(logger, "【角色管理】检查角色代码是否存在失败: 角色代码为空");
                LogUtils.logBusiness(logger, "ROLE_CODE_CHECK_FAIL", "system", "检查角色代码是否存在失败: 角色代码为空");
                return false;
            }
            
            LogUtils.debug(logger, () -> "【角色管理】开始检查角色代码是否已存在: 角色代码=" + roleCode + ", 排除角色ID=" + id);
            LogUtils.info(logger, () -> "【角色管理】准备执行角色代码检查，代码: " + roleCode + ", 排除ID: " + id);
            
            Integer count = roleMapper.checkRoleCode(roleCode, id);
            boolean exists = count != null && count > 0;
            
            LogUtils.debug(logger, () -> "【角色管理】角色代码检查结果: 角色代码=" + roleCode + ", 存在: " + exists + ", 计数: " + count);
            LogUtils.info(logger, () -> "【角色管理】角色代码检查完成: 代码'" + roleCode + "' " + (exists ? "已存在" : "不存在"));
            
            LogUtils.logPerformance(logger, "checkRoleCodeExists", startTime, System.currentTimeMillis());
            LogUtils.logBusiness(logger, "ROLE_CODE_CHECK_COMPLETE", "system", "角色代码检查完成: 代码=" + roleCode + ", 存在=" + exists);
            return exists;
        } catch (Exception e) {
            LogUtils.error(logger, "【角色管理】检查角色代码是否已存在异常: 角色代码=" + roleCode + ", 错误: " + LogUtils.formatException(e));
            LogUtils.logBusiness(logger, "ROLE_CODE_CHECK_EXCEPTION", "system", "检查角色代码是否存在异常: " + e.getMessage());
            throw e;
        }
    }
    
    /**
     * 分页查询角色列表
     * @param page 页码
     * @param pageSize 每页数量
     * @param params 查询参数
     * @return 角色列表和总数
     */
    @Override
    public Map<String, Object> getRoleList(Integer page, Integer pageSize, Map<String, Object> params) {
        long startTime = System.currentTimeMillis();
        LogUtils.logBusiness(logger, "ROLE_LIST_QUERY_START", "system", "开始分页查询角色列表");
        
        // 创建原始参数的final版本
        final Integer originalPage = page;
        final Integer originalPageSize = pageSize;
        final Map<String, Object> originalParams = params;
        
        // 参数校验和默认值设置
        if (page == null || page <= 0) {
            page = 1;
            LogUtils.warn(logger, "【角色管理】页码参数无效，自动设置为默认值: {}", page);
        }
        if (pageSize == null || pageSize <= 0) {
            pageSize = 10;
            LogUtils.warn(logger, "【角色管理】每页大小参数无效，自动设置为默认值: {}", pageSize);
        }
        if (params == null) {
            params = new HashMap<>();
            LogUtils.warn(logger, "【角色管理】查询参数为空，使用空Map替代");
        }
        
        // 创建处理后参数的final版本
        final Integer finalPage = page;
        final Integer finalPageSize = pageSize;
        final Map<String, Object> finalParams = params;
        
        try {
            LogUtils.debug(logger, () -> "【角色管理】分页查询角色列表请求开始，页码=" + originalPage + ", 每页数量=" + originalPageSize + ", 查询参数=" + originalParams);
            LogUtils.info(logger, () -> "【角色管理】准备执行角色列表分页查询，页码: " + finalPage + ", 每页大小: " + finalPageSize);
            
            // 计算偏移量
            Integer offset = (page - 1) * pageSize;
            LogUtils.debug(logger, () -> "【角色管理】计算查询偏移量: " + offset);
            
            // 查询角色列表
            LogUtils.info(logger, () -> "【角色管理】准备查询角色列表，偏移量: " + offset + ", 每页数量: " + finalPageSize + ", 查询参数: " + finalParams);
            List<Role> roleList = roleMapper.findByPage(params, offset, pageSize);
            LogUtils.debug(logger, () -> "【角色管理】查询角色列表完成，当前页获取角色数量: " + (roleList != null ? roleList.size() : 0));
            
            // 记录当前页角色的简要信息
            if (roleList != null && !roleList.isEmpty()) {
                StringBuilder roleNames = new StringBuilder();
                for (int i = 0; i < Math.min(5, roleList.size()); i++) {
                    if (i > 0) roleNames.append(", ");
                    roleNames.append(roleList.get(i).getRoleName()).append("(ID:").append(roleList.get(i).getId()).append(")");
                }
                if (roleList.size() > 5) {
                    roleNames.append(" 等 " + roleList.size() + " 个角色");
                }
                LogUtils.debug(logger, () -> "【角色管理】当前页角色列表: " + roleNames.toString());
            }
            
            // 查询角色总数
            LogUtils.info(logger, () -> "【角色管理】准备查询角色总数量，查询参数: " + finalParams);
            Integer total = roleMapper.count(params);
            LogUtils.debug(logger, () -> "【角色管理】查询角色总数量完成，总记录数: " + (total != null ? total : 0));
            
            // 组装返回结果
            LogUtils.debug(logger, () -> "【角色管理】开始构建返回结果对象");
            Map<String, Object> result = new HashMap<>();
            result.put("list", roleList);
            result.put("total", total);
            
            LogUtils.info(logger, () -> "【角色管理】分页查询角色列表成功: 页码=" + finalPage + ", 每页数量=" + finalPageSize + ", 总记录数=" + total + ", 当前页记录数=" + (roleList != null ? roleList.size() : 0));
            LogUtils.logPerformance(logger, "getRoleList", startTime, System.currentTimeMillis());
            LogUtils.logBusiness(logger, "ROLE_LIST_QUERY_SUCCESS", "system", "分页查询角色列表成功，总记录数: " + total + ", 当前页: " + (roleList != null ? roleList.size() : 0) + ", 页码: " + finalPage);
            return result;
        } catch (Exception e) {
            LogUtils.error(logger, "【角色管理】分页查询角色列表异常: 页码=" + originalPage + ", 每页数量=" + originalPageSize + ", 错误: " + LogUtils.formatException(e));
            LogUtils.logBusiness(logger, "ROLE_LIST_QUERY_FAIL", "system", "分页查询角色列表失败: " + e.getMessage());
            throw e;
        }
    }
    
    /**
     * 更新角色状态
     * @param id 角色ID
     * @param status 状态（0-禁用，1-启用）
     * @return 更新结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean updateRoleStatus(Long id, Integer status) {
        long startTime = System.currentTimeMillis();
        LogUtils.logBusiness(logger, "ROLE_STATUS_UPDATE_START", "system", "开始更新角色状态");
        try {
            // 参数验证
            if (id == null || id <= 0) {
                LogUtils.warn(logger, "【角色管理】更新角色状态失败: 角色ID不能为空或无效");
                LogUtils.logBusiness(logger, "ROLE_STATUS_UPDATE_FAIL", "system", "更新角色状态失败: 角色ID无效");
                return false;
            }
            
            if (status == null || (status != 0 && status != 1)) {
                LogUtils.warn(logger, "【角色管理】更新角色状态失败: 状态值无效，必须是0(禁用)或1(启用)");
                LogUtils.logBusiness(logger, "ROLE_STATUS_UPDATE_FAIL", "system", "更新角色状态失败: 状态值无效");
                return false;
            }
            
            String statusText = status == 1 ? "启用" : "禁用";
            LogUtils.logBusiness(logger, "ROLE_STATUS_UPDATE_ATTEMPT", "system", "更新角色状态尝试: 角色ID=" + id + ", 目标状态=" + statusText + "(" + status + ")");
            LogUtils.debug(logger, () -> "【角色管理】更新角色状态请求开始，角色ID: " + id + ", 目标状态: " + statusText + "(" + status + ")");
            
            // 检查角色是否存在
            LogUtils.info(logger, () -> "【角色管理】准备检查角色是否存在，ID: " + id);
            Role existingRole = roleMapper.findById(id);
            if (existingRole == null) {
                LogUtils.warn(logger, "【角色管理】更新角色状态失败: 未找到ID为 {} 的角色", id);
                LogUtils.logBusiness(logger, "ROLE_STATUS_UPDATE_FAIL", "system", "更新角色状态失败: 角色不存在，ID=" + id);
                return false;
            }
            
            // 检查状态是否已经是目标状态
            if (existingRole.getStatus().equals(status)) {
                LogUtils.info(logger, () -> "【角色管理】角色状态无需更新: ID=" + id + ", 状态已经是 " + statusText + "(" + status + ")");
                LogUtils.logBusiness(logger, "ROLE_STATUS_UPDATE_NO_CHANGE", "system", "角色状态无需更新: ID=" + id + ", 状态=" + statusText + "(" + status + ")");
                return true; // 虽然没有变更，但返回成功表示操作有效
            }
            
            LogUtils.info(logger, () -> "【角色管理】找到待更新状态的角色: " + existingRole.getRoleName() + " (ID: " + existingRole.getId() + "), 当前状态: " + (existingRole.getStatus() == 1 ? "启用" : "禁用") + "(" + existingRole.getStatus() + "), 目标状态: " + statusText + "(" + status + ")");
            
            // 创建更新对象
            LogUtils.debug(logger, () -> "【角色管理】创建角色状态更新对象");
            Role role = new Role();
            role.setId(id);
            role.setStatus(status);
            role.setUpdateTime(LocalDateTime.now());
            LogUtils.debug(logger, () -> "【角色管理】角色状态更新对象创建完成，更新时间: " + role.getUpdateTime());
            
            LogUtils.info(logger, () -> "【角色管理】开始执行数据库状态更新操作，ID: " + id + ", 新状态: " + statusText + "(" + status + ")");
            boolean result = updateById(role);
            
            if (result) {
                LogUtils.info(logger, () -> "【角色管理】更新角色状态成功: 角色ID=" + id + " - " + existingRole.getRoleName() + ", 从状态 " + (existingRole.getStatus() == 1 ? "启用" : "禁用") + "(" + existingRole.getStatus() + ") 变更为 " + statusText + "(" + status + ")");
                LogUtils.logBusiness(logger, "ROLE_STATUS_UPDATE_SUCCESS", "system", "更新角色状态成功: ID=" + id + ", 名称=" + existingRole.getRoleName() + ", 状态从 " + existingRole.getStatus() + " 变更为 " + status);
            } else {
                LogUtils.warn(logger, "【角色管理】更新角色状态失败: 角色ID={}, 目标状态={}", id, status);
                LogUtils.logBusiness(logger, "ROLE_STATUS_UPDATE_FAIL", "system", "更新角色状态失败: ID=" + id + ", 目标状态=" + status);
            }
            
            LogUtils.logPerformance(logger, "updateRoleStatus", startTime, System.currentTimeMillis());
            return result;
        } catch (Exception e) {
            LogUtils.error(logger, "【角色管理】更新角色状态异常: 角色ID=" + id + ", 目标状态=" + status + ", 错误: " + LogUtils.formatException(e));
            LogUtils.logBusiness(logger, "ROLE_STATUS_UPDATE_EXCEPTION", "system", "更新角色状态异常: " + e.getMessage());
            throw e;
        }
    }
    
    // 辅助方法：比较两个对象是否相等，处理null情况
    private boolean equals(Object a, Object b) {
        if (a == null && b == null) return true;
        if (a == null || b == null) return false;
        return a.equals(b);
    }
}